/**
 * @file thread3.c
 * @brief 电池管理与CAN通信线程实现 - 基于E-UAVCAN协议
 * 
 * 该线程负责通过CAN总线接口监控和管理电池系统。主要功能包括：
 * 1. 初始化CAN总线接口
 * 2. 接收和解析电池发送的E-UAVCAN协议CAN数据帧
 * 3. 监控电池状态信息，包括总电压、电流、剩余容量等
 * 4. 监测电池保护状态，如过压、欠压、过温等
 * 5. 提供电池信息查询接口给其他线程使用
 * 6. 处理CAN通信错误
 * 
 * E-UAVCAN协议基于标准CANBus 2.0B协议，基于29bit的扩展帧，通信速率为1Mbps
 * 
 * @note 该线程是系统电源管理的核心，确保无人机能够安全稳定地运行
 * 
 * @author 伞控无人机项目组
 * @date 2023
 */

/******************************************************************************
 * E-UAVCAN电池通信协议详解
 * 
 * 1. 协议基本信息:
 *    - 基于标准CANBus 2.0B协议的29位扩展帧
 *    - 通信速率: 1Mbps
 *    - BMS默认Node ID: 0x16 (22)
 * 
 * 2. CAN ID结构(29位扩展帧ID):
 *    [28:26] 优先级(Priority): 3位 (0-7)
 *    [25:10] 消息类型ID(Message type ID): 16位 (电池信息为0x1092)
 *    [9]     服务或消息标志(Service or message): 1位 (0表示消息)
 *    [8:2]   源节点ID(Source node ID): 7位 (1-127, 0表示未知, BMS为0x16)
 *    [1:0]   目标节点ID(Destination Node Id): 7位 (1-127, 0表示广播/未知)
 * 
 * 3. 传输类型:
 *    3.1 单帧传输:
 *        - 格式: [N字节有效负载(Payload)][1字节尾字节(Tail byte)]
 *        - 尾字节结构:
 *          [7]    开始传输标志(Start of transfer): 1=起始帧 (单帧为1)
 *          [6]    结束传输标志(End of transfer): 1=结束帧 (单帧为1)
 *          [5]    切换位(Toggle bit): 单帧恒为0
 *          [4:0]  传输ID(Transfer ID): 5位(0-31), 用于识别传输序列
 * 
 *    3.2 多帧传输:
 *        - 第一帧: [CRC低字节][CRC高字节][5字节有效负载][尾字节]
 *          尾字节: start=1, end=0, toggle=0, transfer_id=0-31
 *        - 中间帧: [7字节有效负载][尾字节]
 *          尾字节: start=0, end=0, toggle=交替0/1, transfer_id=0-31
 *        - 最后帧: [N字节有效负载(N≤7)][尾字节]
 *          尾字节: start=0, end=1, toggle=交替0/1, transfer_id=0-31
 * 
 * 4. 电池信息数据结构(消息类型ID=0x1092):
 *    - 总长度: 128字节 (需要多帧传输)
 *    - 主要字段(按2字节对齐):
 *      * 厂商编号(short): 2字节
 *      * 电池型号编码(short): 2字节, 备注=1
 *      * 电池电压(unsigned short): 2字节, 单位(mV)
 *      * 充放电电流(short): 2字节, 单位(10mA), 注: 正数充电, 负数放电
 *      * 电池温度(short): 2字节, 单位(0.1℃)
 *      * 电量百分比(unsigned short): 2字节, 单位(%)
 *      * 循环次数(unsigned short): 2字节, 单位(次数)
 *      * 健康状况(short): 2字节, 单位(%), 根据电池容量特性曲线分析生成
 *      * 单体电压1-14(unsigned short): 每个2字节, 单位(mV)
 *      * 电池设计容量(unsigned short): 2字节, 单位(mAh), 备注=0
 *      * 电池剩余容量(unsigned short): 2字节, 单位(mAh), 备注=0
 *      * 错误信息(Uint32): 4字节, 每位表示一种错误类型状态
 *      * 电池序列号(char): 16字节
 * 
 * 5. 错误信息位定义(Bit0-Bit12):
 *    - Bit0: 电池单体过压
 *    - Bit1: 电池单体欠压
 *    - Bit2: 总压过压
 *    - Bit3: 总压欠压
 *    - Bit4: 充电过温
 *    - Bit5: 充电低温
 *    - Bit6: 放电过温
 *    - Bit7: 放电低温
 *    - Bit8: 充电过流
 *    - Bit9: 放电过流
 *    - Bit10: 短路
 *    - Bit11: 前端检测错误
 *    - Bit12: MOS过温
 ******************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <linux/socket.h>
#include <linux/can.h>
#include <linux/can/error.h>
#include <linux/can/raw.h>
#include <fcntl.h>
#include <errno.h>
#include <time.h>
#include <pthread.h>
#include <stdint.h>
#include "thread3.h"

// 模块名称定义
// 使用标准模块名，避免与 log_modules.h 的定义重复
#ifndef THREAD3_MODULE_NAME
#define THREAD3_MODULE_NAME LOG_MODULE_CAN
#endif

#ifndef AF_CAN
#define AF_CAN 29
#endif

#ifndef PF_CAN
#define PF_CAN AF_CAN
#endif

// CAN ID相关定义
#define CAN_EFF_FLAG 0x80000000U  // 扩展帧标志
#define CAN_RTR_FLAG 0x40000000U  // 远程帧标志
#define CAN_ERR_FLAG 0x20000000U  // 错误帧标志
#define CAN_EFF_MASK 0x1FFFFFFFU  // 扩展帧ID掩码

// 定义CRC校验参数 - 根据协议中的CRC_CCITT标准
#define CRC_CCITT_INIT 0xFFFFU
#define CRC_CCITT_POLY 0x1021U

// 多帧传输缓冲区大小
#define MAX_BUFFER_SIZE 256

// 接收超时和重连相关定义
#define MAX_NO_DATA_TIME 30    // 30秒无数据则尝试重连
#define MIN_RECONNECT_WAIT 5   // 最小重连等待时间(秒)
#define MAX_RECONNECT_WAIT 60  // 最大重连等待时间(秒)

// 全局变量定义
power_info_t g_power_info;
pthread_mutex_t g_power_info_mutex = PTHREAD_MUTEX_INITIALIZER;

// CAN套接字
static int g_can_socket = -1;
// 前向声明：关闭CAN接口
static void close_can_interface(void);

// 多帧传输状态
static struct {
    transfer_state_t state;      // 当前传输状态
    uint8_t buffer[MAX_BUFFER_SIZE]; // 数据缓冲区
    size_t buffer_pos;           // 当前缓冲区位置
    uint8_t last_transfer_id;    // 上一个传输ID
    uint8_t expected_toggle;     // 期望的切换位
    uint16_t crc;                // 传输CRC值
    time_t last_frame_time;      // 上一帧接收时间
} g_transfer_ctx = {
    .state = TRANSFER_IDLE,
    .buffer_pos = 0,
    .last_transfer_id = 0,
    .expected_toggle = 0,
    .crc = 0,
    .last_frame_time = 0
};

/**
 * @brief 处理CAN总线错误帧
 * 
 * @param fr CAN错误帧
 */
static void handle_err_frame(const struct can_frame *fr) {
    if (fr == NULL) {
        return;
    }
    
    if (fr->can_id & CAN_ERR_FLAG) {
        // 帧格式错误
        if (fr->can_id & CAN_ERR_PROT) {
            if (fr->data[2] & CAN_ERR_PROT_FORM) {
                LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN总线协议错误：帧格式错误");
            }
        }
        
        // CAN控制器问题
        if (fr->can_id & CAN_ERR_CRTL) {
            if (fr->data[1] & CAN_ERR_CRTL_RX_OVERFLOW) {
                LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN控制器接收溢出");
            }
            if (fr->data[1] & CAN_ERR_CRTL_TX_OVERFLOW) {
                LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN控制器发送溢出");
            }
        }
        
        // 总线关闭
        if (fr->can_id & CAN_ERR_BUSOFF) {
            LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN总线关闭状态，尝试重连...");
            close(g_can_socket);
            sleep(1);  // 等待1秒后尝试重新初始化
            init_can_interface();
        }
        
        // ACK错误 - 没有节点应答
        if (fr->can_id & CAN_ERR_ACK) {
            LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN总线ACK错误：没有节点应答");
        }
        
        // 总线错误
        if (fr->can_id & CAN_ERR_BUSERROR) {
            LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN总线错误");
        }
    }
}

/**
 * @brief 打印CAN帧信息（调试用）
 * 
 * @param fr CAN帧
 */
static void print_frame(struct can_frame *fr) {
    if (fr == NULL) {
        return;
    }
    
    int i;
    if (fr->can_id & CAN_ERR_FLAG) {
        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "错误帧 ID: 0x%X", fr->can_id & CAN_ERR_MASK);
        return;
    }
    
    if (fr->can_id & CAN_EFF_FLAG) {
        // 扩展帧
        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "扩展帧 ID: 0x%X", fr->can_id & CAN_EFF_MASK);
    } else {
        // 标准帧
        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "标准帧 ID: 0x%X", fr->can_id);
    }
    
    if (fr->can_id & CAN_RTR_FLAG) {
        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "远程帧");
    } else {
        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "数据帧: [%d]", fr->can_dlc);
        
        // 打印数据内容（十六进制）
        char data_hex[50] = {0};
        char temp[5];
        for (i = 0; i < fr->can_dlc; i++) {
            snprintf(temp, sizeof(temp), "%02X ", fr->data[i]);
            strcat(data_hex, temp);
        }
        
        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "数据: %s", data_hex);
    }
}

/**
 * @brief 计算CRC-CCITT校验值
 * 
 * @param data 数据缓冲区
 * @param len 数据长度
 * @return uint16_t CRC校验值
 */
static uint16_t calculate_crc_ccitt(const uint8_t *data, size_t len) {
    uint16_t crc = CRC_CCITT_INIT;
    size_t i, j;
    
    for (i = 0; i < len; i++) {
        crc ^= (uint16_t)data[i] << 8;
        for (j = 0; j < 8; j++) {
            if (crc & 0x8000) {
                crc = (crc << 1) ^ CRC_CCITT_POLY;
            } else {
                crc = crc << 1;
            }
        }
    }
    
    return crc;
}

/**
 * @brief 重置多帧传输缓冲区
 */
static void reset_multi_frame_buffer(void) {
    g_transfer_ctx.state = TRANSFER_IDLE;
    g_transfer_ctx.buffer_pos = 0;
    g_transfer_ctx.expected_toggle = 0;
    g_transfer_ctx.crc = 0;
}

/**
 * @brief 检查多帧传输超时
 * 
 * @return int 1表示超时，0表示未超时
 */
static int check_transfer_timeout(void) {
    // 如果当前没有传输进行，不需要检查超时
    if (g_transfer_ctx.state == TRANSFER_IDLE) {
        return 0;
    }
    
    time_t now = time(NULL);
    if (now - g_transfer_ctx.last_frame_time > 5) {  // 5秒超时
        LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "多帧传输超时");
        reset_multi_frame_buffer();
        return 1;
    }
    return 0;
}

/**
 * @brief 设置CAN总线接口参数
 * 
 * @param device_name 设备名称
 * @param bitrate 比特率
 * @return int 成功返回0，失败返回负数
 */
static int setup_can_interface(const char *device_name, int bitrate) {
    char command[100];
    int ret;
    
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "开始配置CAN接口: %s，波特率: %d", device_name, bitrate);
    
    // 停止CAN接口
    snprintf(command, sizeof(command), "ip link set %s down", device_name);
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "执行命令: %s", command);
    ret = system(command);
    if (ret != 0) {
        LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "关闭CAN接口失败: %s (返回码: %d)", device_name, ret);
    } else {
        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN接口已关闭: %s", device_name);
    }
    
    // 设置CAN接口参数 - 波特率, 采样点, 重启模式
    snprintf(command, sizeof(command), 
             "ip link set %s type can bitrate %d sample-point 0.875 restart-ms 100", 
             device_name, bitrate);
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "执行命令: %s", command);
    ret = system(command);
    if (ret != 0) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "设置CAN接口参数失败 (返回码: %d)", ret);
        return -1;
    } else {
        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN接口参数设置成功");
    }
    
    // 启动CAN接口
    snprintf(command, sizeof(command), "ip link set %s up", device_name);
    LOG_DEBUG(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "执行命令: %s", command);
    ret = system(command);
    if (ret != 0) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "启动CAN接口失败 (返回码: %d)", ret);
        return -1;
    } else {
        LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN接口启动成功: %s", device_name);
    }
    
    return 0;
}

// 初始化CAN接口
int init_can_interface(void)
{
    int s;
    int ret;
    struct sockaddr_can addr;
    struct ifreq ifr;
    
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "初始化CAN接口: %s", CAN_DEVICE);
    
    // 先检查CAN设备是否存在
    struct stat st;
    char dev_path[64];
    snprintf(dev_path, sizeof(dev_path), "/sys/class/net/%s", CAN_DEVICE);
    if (stat(dev_path, &st) != 0) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN设备 %s 不存在", CAN_DEVICE);
        return -1;
    }
    
    // 先配置CAN接口
    ret = setup_can_interface(CAN_DEVICE, CAN_BITRATE);
    if (ret < 0) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "配置CAN接口失败");
        return -1;
    }
    
    // 创建套接字
    s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if (s < 0) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "创建CAN套接字失败: %s", strerror(errno));
        return -1;
    }
    
    // 设置非阻塞模式
    int flags = fcntl(s, F_GETFL, 0);
    if (flags < 0) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "获取套接字标志失败: %s", strerror(errno));
        close(s);
        return -1;
    }
    ret = fcntl(s, F_SETFL, flags | O_NONBLOCK);
    if (ret < 0) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "设置非阻塞模式失败: %s", strerror(errno));
        close(s);
        return -1;
    }
    
    // 设置接收缓冲区大小
    int recv_buf_size = 1024 * 1024; // 1MB接收缓冲区
    ret = setsockopt(s, SOL_SOCKET, SO_RCVBUF, &recv_buf_size, sizeof(recv_buf_size));
    if (ret < 0) {
        LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "设置接收缓冲区大小失败: %s", strerror(errno));
        // 不退出，这不是致命错误
    }
    
    // 配置CAN接口
    strcpy(ifr.ifr_name, CAN_DEVICE);
    ret = ioctl(s, SIOCGIFINDEX, &ifr);
    if (ret < 0) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "获取CAN接口索引失败: %s", strerror(errno));
        close(s);
        return -1;
    }
    
    // 绑定套接字到CAN接口
    addr.can_family = PF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
    ret = bind(s, (struct sockaddr *)&addr, sizeof(addr));
    if (ret < 0) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "绑定CAN套接字失败: %s", strerror(errno));
        close(s);
        return -1;
    }
    
    // 设置过滤规则，只接收电池信息帧
    // E-UAVCAN协议中，BATTERY_INFO_CAN_ID是根据优先级、消息类型ID、源节点等构建的
    struct can_filter rfilter[1];
    
    // 过滤器1：接收来自BMS的电池信息
    rfilter[0].can_id = BATTERY_INFO_CAN_ID | CAN_EFF_FLAG;
    rfilter[0].can_mask = CAN_EFF_MASK | CAN_EFF_FLAG;
    
    ret = setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter));
    if (ret < 0) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "设置CAN过滤规则失败: %s", strerror(errno));
        close(s);
        return -1;
    }
    
    // 设置接收错误帧
    int recv_err_frames = 1;
    ret = setsockopt(s, SOL_CAN_RAW, CAN_RAW_ERR_FILTER, &recv_err_frames, sizeof(recv_err_frames));
    if (ret < 0) {
        LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "设置接收错误帧失败: %s", strerror(errno));
        // 不退出，这不是致命错误
    }
    
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN接口初始化成功，波特率: %d bps", CAN_BITRATE);
    return s;
}

// 发送CAN帧
int send_can_frame(int socket, uint32_t can_id, uint8_t *data, uint8_t len)
{
    if (socket < 0) {
        return -1;
    }
    
    struct can_frame frame;
    memset(&frame, 0, sizeof(frame));
    
    frame.can_id = can_id | CAN_EFF_FLAG;  // 使用扩展帧
    frame.can_dlc = len;
    memcpy(frame.data, data, len);
    
    return write(socket, &frame, sizeof(frame));
}

// 检查特定错误是否存在
int check_battery_error(uint32_t error_flag)
{
    pthread_mutex_lock(&g_power_info_mutex);
    int result = (g_power_info.error_flags & error_flag) ? 1 : 0;
    pthread_mutex_unlock(&g_power_info_mutex);
    return result;
}

// 解析单帧电池信息（适用于E-UAVCAN协议单帧传输）
static void parse_single_frame_battery_info(const struct can_frame *frame, power_info_t *info)
{
    if (frame->can_dlc < 2) { // 至少需要一个有效字节加一个尾字节
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "电池信息帧数据长度不足");
        return;
    }
    
    // E-UAVCAN单帧格式: [Transfer payload][Tail byte]
    // 数据为7字节有效负载 + 1字节尾字节
    // 尾字节格式: [Start of transfer(1bit)][End of transfer(1bit)][Toggle(1bit)][Transfer ID(5bit)]
    
    // 解析尾字节
    uint8_t tail_byte = frame->data[frame->can_dlc - 1];
    info->start_of_transfer = (tail_byte >> 7) & 0x01;
    info->end_of_transfer = (tail_byte >> 6) & 0x01;
    info->toggle_bit = (tail_byte >> 5) & 0x01;
    info->transfer_id = tail_byte & 0x1F;
    
    // 检查是否是单帧传输
    // 单帧传输的开始和结束标志都为1，切换位为0
    if (info->start_of_transfer == 1 && info->end_of_transfer == 1 && info->toggle_bit == 0) {
        // 单帧有效载荷长度
        uint8_t payload_len = frame->can_dlc - 1;
        
        if (payload_len >= 6) { // 确保有足够的数据
            // 前2字节: 厂商编号
            info->manufacturer_id = (frame->data[0] << 8) | frame->data[1];
            
            // 第3-4字节: 电池型号编码
            info->battery_type = (frame->data[2] << 8) | frame->data[3];
            
            // 第5-6字节: 电池电压，单位(mV)
            info->total_voltage = (frame->data[4] << 8) | frame->data[5];
            
            LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "解析单帧电池信息: 厂商ID=0x%04X, 型号=0x%04X, 总电压=%dmV",
                   info->manufacturer_id, info->battery_type, info->total_voltage);
            
            // 标记数据为有效
            info->data_valid = 1;
        } else {
            LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "单帧数据长度不足: %d字节", payload_len);
        }
    } else {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "单帧标志位错误: start=%d, end=%d, toggle=%d", 
               info->start_of_transfer, info->end_of_transfer, info->toggle_bit);
    }
}

// 解析完整的电池信息（从多帧传输缓冲区解析）
static void parse_complete_battery_info(const uint8_t *buffer, size_t length, power_info_t *info)
{
    if (length < 128) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "电池信息数据不完整: %zu字节 (期望至少128字节)", length);
        return;
    }
    
    // 安全检查 - 确保所有访问都在缓冲区范围内
    if (buffer == NULL) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "解析电池信息时传入了空缓冲区");
        return;
    }
    
    // 数据偏移量，从0开始
    size_t offset = 0;
    
    // 解析厂商编号 (2字节)
    if (offset + 2 <= length) {
        info->manufacturer_id = (buffer[offset] << 8) | buffer[offset+1];
        offset += 2;
    } else {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "解析厂商编号时超出缓冲区范围");
        return;
    }
    
    // 解析电池型号编码 (2字节)
    if (offset + 2 <= length) {
        info->battery_type = (buffer[offset] << 8) | buffer[offset+1];
        offset += 2;
    } else {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "解析电池型号时超出缓冲区范围");
        return;
    }
    
    // 解析电池电压 (2字节)，单位(mV)
    if (offset + 2 <= length) {
        info->total_voltage = (buffer[offset] << 8) | buffer[offset+1];
        offset += 2;
    } else {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "解析电池电压时超出缓冲区范围");
        return;
    }
    
    // 解析充放电电流 (2字节)，单位(10mA)，正为充电，负为放电
    if (offset + 2 <= length) {
        info->current = (int16_t)((buffer[offset] << 8) | buffer[offset+1]);
        offset += 2;
    } else {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "解析充放电电流时超出缓冲区范围");
        return;
    }
    
    // 解析电池温度 (2字节)，单位(0.1℃)
    if (offset + 2 <= length) {
        info->temperature = (int16_t)((buffer[offset] << 8) | buffer[offset+1]);
        offset += 2;
    } else {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "解析电池温度时超出缓冲区范围");
        return;
    }
    
    // 解析电量百分比 (2字节)，单位(%)
    if (offset + 2 <= length) {
        info->remaining_capacity = (buffer[offset] << 8) | buffer[offset+1];
        offset += 2;
    } else {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "解析电量百分比时超出缓冲区范围");
        return;
    }
    
    // 解析循环次数 (2字节)
    if (offset + 2 <= length) {
        info->cycles = (buffer[offset] << 8) | buffer[offset+1];
        offset += 2;
    } else {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "解析循环次数时超出缓冲区范围");
        return;
    }
    
    // 解析健康状况 (2字节)，单位(%)
    if (offset + 2 <= length) {
        info->health_status = (buffer[offset] << 8) | buffer[offset+1];
        offset += 2;
    } else {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "解析健康状况时超出缓冲区范围");
        return;
    }
    
    // 解析单体电压 (每个2字节)，单位(mV)
    info->cell_count = 0;
    for (int i = 0; i < 14 && offset + 2 <= length; i++) {
        info->cell_voltages[i] = (buffer[offset] << 8) | buffer[offset+1];
        offset += 2;
        
        // 计算实际单体数量（可能有多余的零值）
        if (info->cell_voltages[i] > 0) {
            info->cell_count = i + 1;
        }
    }
    
    // 检查是否有足够的数据解析电池设计容量
    if (offset + 2 <= length) {
        info->design_capacity = (buffer[offset] << 8) | buffer[offset+1];
        offset += 2;
    } else {
        LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "无法解析电池设计容量，数据不足");
        info->design_capacity = 0;
    }
    
    // 检查是否有足够的数据解析电池剩余容量
    if (offset + 2 <= length) {
        info->remain_capacity = (buffer[offset] << 8) | buffer[offset+1];
        offset += 2;
    } else {
        LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "无法解析电池剩余容量，数据不足");
        info->remain_capacity = 0;
    }
    
    // 检查是否有足够的数据解析错误标志
    if (offset + 4 <= length) {
        info->error_flags = (buffer[offset] << 24) | (buffer[offset+1] << 16) | 
                           (buffer[offset+2] << 8) | buffer[offset+3];
        offset += 4;
    } else {
        LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "无法解析错误标志，数据不足");
        info->error_flags = 0;
    }
    
    // 检查是否有足够的数据解析电池序列号
    if (offset + 16 <= length) {
        memcpy(info->serial_number, buffer + offset, 16);
        info->serial_number[15] = '\0'; // 确保字符串以NULL结尾
    } else {
        LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "无法解析电池序列号，数据不足");
        memset(info->serial_number, 0, sizeof(info->serial_number));
    }
    
    // 打印解析结果
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "\n解析多帧电池信息成功:");
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "厂商ID: 0x%04X", info->manufacturer_id);
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "电池型号: 0x%04X", info->battery_type);
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "总电压: %dmV", info->total_voltage);
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "电流: %d(10mA), %s", 
                info->current, 
                info->current > 0 ? "充电中" : "放电中");
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "温度: %.1f℃", info->temperature * 0.1);
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "电量百分比: %d%%", info->remaining_capacity);
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "健康状况: %d%%", info->health_status);
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "循环次数: %d", info->cycles);
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "电池设计容量: %dmAh", info->design_capacity);
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "电池剩余容量: %dmAh", info->remain_capacity);
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "单体数量: %d", info->cell_count);
    
    // 打印单体电压
    char cell_voltage_str[256] = "单体电压(mV): ";
    char temp[32];
    for (int i = 0; i < info->cell_count; i++) {
        snprintf(temp, sizeof(temp), "%d ", info->cell_voltages[i]);
        strcat(cell_voltage_str, temp);
    }
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "%s", cell_voltage_str);
    
    // 检查单体电压差异
    if (info->cell_count > 1) {
        uint16_t min_voltage = UINT16_MAX;
        uint16_t max_voltage = 0;
        for (int i = 0; i < info->cell_count; i++) {
            if (info->cell_voltages[i] < min_voltage) {
                min_voltage = info->cell_voltages[i];
            }
            if (info->cell_voltages[i] > max_voltage) {
                max_voltage = info->cell_voltages[i];
            }
        }
        LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "单体电压差异: %dmV", max_voltage - min_voltage);
        
        // 检查单体电压差异是否过大（超过100mV）
        if (max_voltage - min_voltage > 100) {
            LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "单体电压差异过大: %dmV，建议平衡充电", max_voltage - min_voltage);
        }
    }
    
    // 打印错误标志
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "错误标志: 0x%08X", info->error_flags);
    if (info->error_flags) {
        LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "检测到电池错误:");
        if (info->error_flags & ERR_CELL_OVERVOLTAGE) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 单体过压");
        if (info->error_flags & ERR_CELL_UNDERVOLTAGE) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 单体欠压");
        if (info->error_flags & ERR_PACK_OVERVOLTAGE) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 总压过压");
        if (info->error_flags & ERR_PACK_UNDERVOLTAGE) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 总压欠压");
        if (info->error_flags & ERR_CHARGE_OVERTEMP) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 充电过温");
        if (info->error_flags & ERR_CHARGE_UNDERTEMP) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 充电低温");
        if (info->error_flags & ERR_DISCHARGE_OVERTEMP) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 放电过温");
        if (info->error_flags & ERR_DISCHARGE_UNDERTEMP) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 放电低温");
        if (info->error_flags & ERR_CHARGE_OVERCURRENT) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 充电过流");
        if (info->error_flags & ERR_DISCHARGE_OVERCURRENT) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 放电过流");
        if (info->error_flags & ERR_SHORT_CIRCUIT) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 短路");
        if (info->error_flags & ERR_FRONT_END_DETECT) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- 前端检测错误");
        if (info->error_flags & ERR_MOS_OVERTEMP) LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "- MOS过温");
    } else {
        LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "电池状态正常，无错误");
    }
    
    // 打印电池序列号
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "电池序列号: %s", info->serial_number[0] ? info->serial_number : "未知");
}

// 解析多帧电池信息（适用于E-UAVCAN协议多帧传输）
static void parse_multi_frame_battery_info(const struct can_frame *frame, power_info_t *info)
{
    if (frame->can_dlc < 2) { // 至少需要一个有效字节加一个尾字节
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "电池信息多帧数据长度不足");
        return;
    }
    
    // 检查多帧传输是否超时
    check_transfer_timeout();
    
    // 解析尾字节
    uint8_t tail_byte = frame->data[frame->can_dlc - 1];
    uint8_t start_of_transfer = (tail_byte >> 7) & 0x01;
    uint8_t end_of_transfer = (tail_byte >> 6) & 0x01;
    uint8_t toggle_bit = (tail_byte >> 5) & 0x01;
    uint8_t transfer_id = tail_byte & 0x1F;
    
    // 更新接收时间
    g_transfer_ctx.last_frame_time = time(NULL);
    
    // 检查传输ID是否连续(新传输开始除外)
    if (!start_of_transfer && g_transfer_ctx.state == TRANSFER_IN_PROGRESS && 
        g_transfer_ctx.last_transfer_id != 0xFF && transfer_id != g_transfer_ctx.last_transfer_id) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "传输ID不连续: 期望%d, 实际%d", g_transfer_ctx.last_transfer_id, transfer_id);
        reset_multi_frame_buffer();
        return;
    }
    
    // 检查切换位是否正确(对中间帧)
    if (!start_of_transfer && !end_of_transfer && 
        g_transfer_ctx.state == TRANSFER_IN_PROGRESS && toggle_bit != g_transfer_ctx.expected_toggle) {
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "切换位错误: 期望%d, 实际%d", g_transfer_ctx.expected_toggle, toggle_bit);
        reset_multi_frame_buffer();
        return;
    }
    
    // 更新传输ID
    g_transfer_ctx.last_transfer_id = transfer_id;
    
    // 判断帧类型
    if (start_of_transfer && !end_of_transfer) {
        // 这是多帧传输的第一帧 - 格式: [CRC_L][CRC_H][Payload(5字节)][Tail byte]
        
        // 重置缓冲区，准备新的多帧传输
        reset_multi_frame_buffer();
        
        // 设置传输状态为进行中
        g_transfer_ctx.state = TRANSFER_IN_PROGRESS;
        
        // 获取CRC
        if (frame->can_dlc >= 3) { // 确保至少有CRC低字节、高字节和尾字节
            uint16_t crc = (frame->data[0] | (frame->data[1] << 8));
            g_transfer_ctx.crc = crc;
            info->crc = crc;
            
            // 设置帧类型标志
            info->multi_frame_transfer = 1;
            info->start_of_transfer = 1;
            info->end_of_transfer = 0;
            info->toggle_bit = 0;
            info->transfer_id = transfer_id;
            
            // 复制5字节有效负载到缓冲区
            uint8_t payload_len = frame->can_dlc - 3; // 减去CRC低字节、高字节和尾字节
            if (payload_len > 0 && g_transfer_ctx.buffer_pos + payload_len <= MAX_BUFFER_SIZE) {
                memcpy(g_transfer_ctx.buffer + g_transfer_ctx.buffer_pos, &frame->data[2], payload_len);
                g_transfer_ctx.buffer_pos += payload_len;
            }
            
            LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "接收到多帧传输的第一帧: CRC=0x%04X, 传输ID=%d, 有效负载=%d字节", 
                   crc, transfer_id, payload_len);
        } else {
            LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "第一帧数据长度不足: %d字节", frame->can_dlc);
            reset_multi_frame_buffer();
        }
    }
    else if (!start_of_transfer && !end_of_transfer) {
        // 这是多帧传输的中间帧 - 格式: [Payload(7字节)][Tail byte]
        
        // 检查传输状态
        if (g_transfer_ctx.state != TRANSFER_IN_PROGRESS) {
            LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "接收到中间帧但传输未开始，忽略");
            return;
        }
        
        uint8_t payload_len = frame->can_dlc - 1; // 减去尾字节
        if (payload_len > 0 && g_transfer_ctx.buffer_pos + payload_len <= MAX_BUFFER_SIZE) {
            memcpy(g_transfer_ctx.buffer + g_transfer_ctx.buffer_pos, frame->data, payload_len);
            g_transfer_ctx.buffer_pos += payload_len;
        } else if (g_transfer_ctx.buffer_pos + payload_len > MAX_BUFFER_SIZE) {
            LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "缓冲区溢出: 当前%zu字节, 新增%d字节, 最大%d字节", 
                   g_transfer_ctx.buffer_pos, payload_len, MAX_BUFFER_SIZE);
            reset_multi_frame_buffer();
            return;
        }
        
        // 更新期望的切换位
        g_transfer_ctx.expected_toggle = !g_transfer_ctx.expected_toggle;
        
        LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "接收到多帧传输的中间帧: 切换位=%d, 传输ID=%d, 有效负载=%d字节", 
               toggle_bit, transfer_id, payload_len);
    }
    else if (!start_of_transfer && end_of_transfer) {
        // 这是多帧传输的最后一帧 - 格式: [Payload(N字节)][Tail byte]，N≤7
        
        // 检查传输状态
        if (g_transfer_ctx.state != TRANSFER_IN_PROGRESS) {
            LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "接收到最后一帧但传输未开始，忽略");
            return;
        }
        
        uint8_t payload_len = frame->can_dlc - 1; // 减去尾字节
        
        if (payload_len > 0 && g_transfer_ctx.buffer_pos + payload_len <= MAX_BUFFER_SIZE) {
            memcpy(g_transfer_ctx.buffer + g_transfer_ctx.buffer_pos, frame->data, payload_len);
            g_transfer_ctx.buffer_pos += payload_len;
        } else if (g_transfer_ctx.buffer_pos + payload_len > MAX_BUFFER_SIZE) {
            LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "缓冲区溢出: 当前%zu字节, 新增%d字节, 最大%d字节", 
                   g_transfer_ctx.buffer_pos, payload_len, MAX_BUFFER_SIZE);
            reset_multi_frame_buffer();
            return;
        }
        
        LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "接收到多帧传输的最后一帧: 传输ID=%d, 总数据长度=%zu字节", 
               transfer_id, g_transfer_ctx.buffer_pos);
        
        // 验证CRC
        uint16_t calculated_crc = calculate_crc_ccitt(g_transfer_ctx.buffer, g_transfer_ctx.buffer_pos);
        if (calculated_crc == g_transfer_ctx.crc) {
            LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CRC校验通过: 0x%04X", calculated_crc);
            
            // 传输完成
            g_transfer_ctx.state = TRANSFER_COMPLETE;
            
            // 解析完整的电池信息
            if (g_transfer_ctx.buffer_pos >= 128) { // 至少应该有128字节数据
                // 从缓冲区解析电池信息
                parse_complete_battery_info(g_transfer_ctx.buffer, g_transfer_ctx.buffer_pos, info);
                
                // 标记数据为有效
                info->data_valid = 1;
            } else {
                LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "数据长度不足: %zu字节 (期望至少128字节)", g_transfer_ctx.buffer_pos);
                g_transfer_ctx.state = TRANSFER_ERROR;
            }
        } else {
            LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CRC校验失败: 计算值=0x%04X, 期望值=0x%04X", calculated_crc, g_transfer_ctx.crc);
            g_transfer_ctx.state = TRANSFER_ERROR;
        }
        
        // 完成多帧传输处理后重置缓冲区
        reset_multi_frame_buffer();
    } else {
        // 非法帧标志组合
        LOG_ERROR(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "非法帧标志组合: start=%d, end=%d", start_of_transfer, end_of_transfer);
        reset_multi_frame_buffer();
    }
}

// 获取电源信息的函数（供其他线程调用）
int get_power_info(power_info_t *info)
{
    // 加锁保护共享数据
    pthread_mutex_lock(&g_power_info_mutex);
    
    // 复制电源信息
    memcpy(info, &g_power_info, sizeof(power_info_t));
    
    // 解锁
    pthread_mutex_unlock(&g_power_info_mutex);
    
    return info->data_valid ? 0 : -1;
}

/**
 * @brief 线程3主函数：电池管理与CAN通信
 * 
 * @param arg 线程参数（未使用）
 * @return void* 线程返回值（未使用）
 */
void *thread3_function(void *arg) {
    (void)arg;
    struct can_frame frame;
    struct timeval tv;
    
    LOG_INFO(LOG_TO_FILE, LOG_MODULE_CAN, "线程3启动: CAN总线通信");

    // 初始化全局电源信息结构
    memset(&g_power_info, 0, sizeof(g_power_info));
    
    // 初始化CAN接口
    if (init_can_interface() < 0) {
        LOG_ERROR(LOG_TO_FILE, LOG_MODULE_CAN, "CAN接口初始化失败，线程3退出");
        return NULL;
    }
    
    LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN接口初始化成功，开始监听电池数据");
    
    time_t last_data_time = time(NULL);
    time_t now;
    int reconnect_wait = MIN_RECONNECT_WAIT;
    
    // 主循环
    while (1) {
        // 检查CAN传输是否超时
        check_transfer_timeout();
        
        // 设置接收超时
        tv.tv_sec = 1;  // 1秒超时
        tv.tv_usec = 0;
        setsockopt(g_can_socket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
        
        // 接收CAN帧
        int ret = recv(g_can_socket, &frame, sizeof(struct can_frame), 0);
        
        if (ret > 0) {
            // 处理接收到的CAN帧
            LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_CAN, "接收到CAN帧: ID=0x%03X, DLC=%d", 
                     frame.can_id, frame.can_dlc);
            
            // 解析CAN数据
            if (frame.can_id & CAN_ERR_FLAG) {
                // 处理错误帧
                handle_err_frame(&frame);
            } else {
                // 打印调试信息
                print_frame(&frame);

                // 检查是否为电池信息ID，匹配E-UAVCAN协议的电池消息ID模式
                // 提取CAN ID的前19位 (优先级[28:26] + 消息类型ID[25:10])
                uint32_t id_prefix = frame.can_id & 0x1FFFC000; // 取前19位
                uint32_t expected_prefix = BATTERY_INFO_CAN_ID & 0x1FFFC000;
                
                if (id_prefix == expected_prefix) {
                    // 获取互斥锁保护共享数据
                    pthread_mutex_lock(&g_power_info_mutex);
                    
                    // 检查尾字节确定是单帧传输还是多帧传输
                    uint8_t tail_byte = frame.data[frame.can_dlc - 1];
                    uint8_t start_of_transfer = (tail_byte >> 7) & 0x01;
                    uint8_t end_of_transfer = (tail_byte >> 6) & 0x01;
                    
                    if (start_of_transfer && end_of_transfer) {
                        // 单帧传输
                        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_CAN, "接收到电池单帧数据");
                        parse_single_frame_battery_info(&frame, &g_power_info);
                    } else {
                        // 多帧传输
                        LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_CAN, "接收到电池多帧数据段");
                        parse_multi_frame_battery_info(&frame, &g_power_info);
                    }
                    
                    pthread_mutex_unlock(&g_power_info_mutex);
                }
            }
        } else if (ret == 0) {
            LOG_DEBUG(LOG_TO_CONSOLE_ONLY, LOG_MODULE_CAN, "CAN接收超时");
        } else {
            LOG_ERROR(LOG_TO_FILE, LOG_MODULE_CAN, "CAN接收错误: %s", strerror(errno));
        }
        
        // 记录CAN通信状态
        LOG_STATE_RECORD(LOG_MODULE_CAN, LOG_STATE_CONN_STAT, "status=active");

        // 检查长时间无数据
        now = time(NULL);
        if (now - last_data_time > MAX_NO_DATA_TIME) {
            LOG_WARN(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "长时间未接收到电池数据, 尝试重新初始化CAN接口");
            
            // 关闭当前套接字
            if (g_can_socket >= 0) {
                close(g_can_socket);
                g_can_socket = -1;
            }
            
            // 等待一段时间后重试
            LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "等待 %d 秒后重试连接", reconnect_wait);
            sleep(reconnect_wait);
            
            // 增加重连等待时间，但不超过最大值
            reconnect_wait = reconnect_wait * 2;
            if (reconnect_wait > MAX_RECONNECT_WAIT) {
                reconnect_wait = MAX_RECONNECT_WAIT;
            }
            
            // 重新初始化CAN接口
            if (init_can_interface() < 0) {
                LOG_ERROR(LOG_TO_FILE, LOG_MODULE_CAN, "CAN接口重新初始化失败");
            } else {
                LOG_INFO(LOG_TO_CONSOLE_ONLY, THREAD3_MODULE_NAME, "CAN接口重新初始化成功");
            }
            
            last_data_time = time(NULL);
        }
        
        // 重置重连等待时间
        reconnect_wait = MIN_RECONNECT_WAIT;
        last_data_time = time(NULL);
    }
    
    close_can_interface();
    LOG_INFO(LOG_TO_FILE, LOG_MODULE_CAN, "线程3退出");
    return NULL;
}

void thread3_stop(void) {
    LOG_INFO(LOG_TO_CONSOLE_ONLY, LOG_MODULE_CAN, "线程3停止中");
    // 这里可以添加停止逻辑
}

// 静态实现：关闭CAN接口
static void close_can_interface(void)
{
    if (g_can_socket >= 0) {
        close(g_can_socket);
        g_can_socket = -1;
        LOG_INFO(LOG_TO_CONSOLE_ONLY, LOG_MODULE_CAN, "CAN接口已关闭");
    }
} 